package com.hy.video.monitor.media.zlm.dto;


import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import com.hy.video.monitor.gb28181.session.SsrcConfig;
import com.hy.video.monitor.media.zlm.ZLMServerConfig;
import org.springframework.util.StringUtils;

import java.io.Serializable;
import java.util.HashMap;

/**
 * @Classname MediaServerItem
 * @Description TODO 流媒体服务器类实体
 * @Date 2022/3/10 10:54
 * @Created by KangJonney
 *          * redis：
 *          * VMP_MEDIA_SERVER_000000_rRbQlHF7Jg0g8yQN：
 *          * { "@type": "com.hy.video.monitor.media.zlm.dto.MediaServerItem",
 *          * "autoConfig": true,
 *          * "createTime": "2022-03-21 10:31:50",
 *          * "currentPort": 30015,
 *          * "defaultServer": true,
 *          * "hookAliveInterval": 10,
 *          * "hookIp": "10.10.23.223",
 *          * "httpPort": 80,
 *          * "httpSSlPort": 443,
 *          * "id": "rRbQlHF7Jg0g8yQN",
 *          * "ip": "10.10.22.100",
 *          * "recordAssistPort": 18081,
 *          * "rtmpPort": 1935,
 *          * "rtmpSSlPort": 0,
 *          * "rtpEnable": true,
 *          * "rtpPortRange": "30000,30500",
 *          * "rtpProxyPort": 10000,
 *          * "rtspPort": 554,
 *          * "rtspSSLPort": 0,
 *          * "sdpIp": "10.10.22.100",
 *          * "secret": "035c73f7-bb6b-4889-a715-d9eb2d1925cc",
 *          * "sendRtpPortRange": "30000,30500",
 *          * "ssrcConfig": {
 *          * "isUsed": [
 *          * "2305",
 *          * "8906"
 *          * ],
 *          * "mediaServerId": "rRbQlHF7Jg0g8yQN",
 *          * "notUsed": [
 *          * "0001",
 *          * "0002",
 *          * "0003",
 *          * "0004"
 *          * ],
 *          *
 *          " playBackSsrc": "1404028916",
 *          " playSsrc": "0404021564",
 *          " ssrcPrefix": "40402"
 *          * },
 *          * "status": true,
 *          * "streamIp": "10.10.22.100",
 *          * "streamNoneReaderDelayMS": 18000,
 *          * "updateTime": "2022-03-21 10:31:50"
 *          * }
 */
@JsonIgnoreProperties(ignoreUnknown = true)
public class MediaServerItem implements Serializable {
    /**
     * 对应vmc配置文件中的id值
     * vmc 服务器唯一id，用于触发hook时区别是哪台服务器,general.mediaServerId
     */
    private String id;
    /**
     * 媒体服务器Ip(必须是网卡ip)
     */
    private String ip;
    /**
     * zlm 调用回调信令服务器接口的ip地址(必须是网卡ip)
     */
    private String hookIp;
    /**
     * vmc在国标信令中使用的ip，此ip为摄像机可以访问到的ip， 置空使用 media.ip
     */
    private String sdpIp;
    /**
     * 传输流的流媒体Ip
     * 返回流地址时的ip，置空使用 media.ip
     */
    private String streamIp;
    /**
     * vmc 对外开放的http接口访问所用的端口
     */
    private int httpPort;
    /**
     * vmc 对外开放的httpss接口访问所用的端口
     */
    private int httpSSlPort;
    /**
     * vmc rtmp服务器对外监听端口
     * RTMP是Real Time Messaging Protocol（实时消息传输协议）的首字母缩写。该协议基于TCP
     * RTMP与HTTP一样，都属于TCP/IP四层模型的应用层
     */
    private int rtmpPort;
    /**
     * vmc rtmps服务器对外监听端口
     */
    private int rtmpSSlPort;
    /**
     * udp和tcp代理服务器，支持rtp(必须是ts或ps类型)代理
     * RTP协议详细说明了在互联网上传递音频和视频的标准数据包格式
     * RTP协议和RTP控制协议RTCP一起使用，该协议基于UDP.
     *
     * RTPProxy的实现比想象中简单，完全符合SIP呼叫通话建立规则，
     * 一个端口申请一个在RTPProxy的代理端口，一个一对一的通话申
     * 请两个RTPProxy的端口，然后RTPProxy在接收到包后转给对应的端口。
     * 其中每个session有两个stream对象，一个是caller(呼叫者)，一个callee(被呼者)，
     * 这样就完成了一对一的包转发和通话流程。流程图见文档。
     *
     */
    private int rtpProxyPort;
    /**
     *  RTSP在体系结构上位于RTP和RTCP之上，它使用TCP或UDP完成数据传输。HTTP与RTSP相比，
     *  HTTP请求由客户机发出，服务器作出响应；使用RTSP时，客户机和服务器都可以发出请求，
     *  即RTSP可以是双向的。RTSP是用来控制声音或影像的多媒体串流协议，并允许同时多个串流需求控制，
     *  传输时所用的网络通讯协定并不在其定义的范围内，服务器端可以自行选择使用TCP或UDP来传送串流内容，
     *  它的语法和运作跟HTTP 1.1类似，但并不特别强调时间同步，所以比较能容忍网络延迟。
     *  HTTP与RTSP相比，HTTP传送HTML，而RTSP传送的是多媒体数据。
     */
    private int rtspPort;

    private int rtspSSLPort;
    /**
     * 是否自动配置ZLM, 如果希望手动配置ZLM, 可以设为false, 不建议新接触的用户修改
     */
    private boolean autoConfig;
    /**
     * vmc 服务器的hook.admin_params=secret
     */
    private String secret;
    /**
     * 某个流无人观看时，触发hook.on_stream_none_reader事件的最大等待时间，单位毫秒
     */
    private int streamNoneReaderDelayMS;
    /**
     * server保活 keepalive hook触发间隔,单位秒，float类型
     */
    private int hookAliveInterval;
    /**
     *  是否启用多端口模式, 开启后会在port-range范围内选择端口用于媒体流传输
     *  port-range: 30000,30500 # 端口范围
     */
    private boolean rtpEnable;
    /**
     * 服务器状态
     */
    private boolean status;
    /**
     * port-range范围内选择端口用于媒体流传输：port-range: 30000,30500 # 端口范围
     */
    private String rtpPortRange;
    /**
     * 国标级联在此范围内选择端口发送媒体流,send-port-range: 30000,30500 # 端口范围
     */
    private String sendRtpPortRange;
    /**
     * 录像辅助服务， 部署此服务可以实现zlm录像的管理与下载， 0 表示不使用
     */
    private int recordAssistPort;

    private String createTime;

    private String updateTime;

    private String lastKeepaliveTime;

    private boolean defaultServer;

    private SsrcConfig ssrcConfig;

    private int currentPort;

    /**
     * 每一台ZML都有一套独立的SSRC列表
     * y字段：十进制整数字符串，标识SSRC值。其中第一位为历史或者实时媒体流的标识位，0为实时，1为历史；
     * 第2位到第6位取20位SIP监控域ID之中的4-8位作为域标识；第7-10位作为域内媒体流标识，
     * 是一个与当前域内产生的媒体流SSRC值后4位不充分的四位十进制整数；
     * y:0 20000 0775
     *
     * 你就简单理解为 同一个端口进来的数据，但是有多路数据怎办? 就可以根据 ssrc 来分离出不同路的数据了。
     *
     * vmc-monitor 先发起呼叫流程， 得到了ssrc和stream id， 再返回url给前端播放， 同时摄像头会推流给zlm
     *
     * 在ApplicationCheckRunner里对mediaServerSsrcMap进行初始化
     *
     */
    private HashMap<String, SsrcConfig> mediaServerSsrcMap;

    public MediaServerItem() {
    }

    public MediaServerItem(ZLMServerConfig zlmServerConfig, String sipIp) {
        id = zlmServerConfig.getGeneralMediaServerId();
        ip = zlmServerConfig.getIp();
        hookIp = StringUtils.isEmpty(zlmServerConfig.getHookIp()) ? sipIp : zlmServerConfig.getHookIp();
        sdpIp = StringUtils.isEmpty(zlmServerConfig.getSdpIp()) ? zlmServerConfig.getIp() : zlmServerConfig.getSdpIp();
        streamIp = StringUtils.isEmpty(zlmServerConfig.getStreamIp()) ? zlmServerConfig.getIp()
                : zlmServerConfig.getStreamIp();
        httpPort = zlmServerConfig.getHttpPort();
        httpSSlPort = zlmServerConfig.getHttpSSLport();
        rtmpPort = zlmServerConfig.getRtmpPort();
        rtmpSSlPort = zlmServerConfig.getRtmpSslPort();
        rtpProxyPort = zlmServerConfig.getRtpProxyPort();
        rtspPort = zlmServerConfig.getRtspPort();
        rtspSSLPort = zlmServerConfig.getRtspSSlport();
        autoConfig = true; // 默认值true;
        secret = zlmServerConfig.getApiSecret();
        streamNoneReaderDelayMS = zlmServerConfig.getGeneralStreamNoneReaderDelayMS();
        hookAliveInterval = zlmServerConfig.getHookAliveInterval();
        rtpEnable = false; // 默认使用单端口;直到用户自己设置开启多端口
        rtpPortRange = zlmServerConfig.getPortRange().replace("_", ","); // 默认使用30000,30500作为级联时发送流的端口号
        sendRtpPortRange = "30000,30500"; // 默认使用30000,30500作为级联时发送流的端口号
        recordAssistPort = 0; // 默认关闭

    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getIp() {
        return ip;
    }

    public void setIp(String ip) {
        this.ip = ip;
    }

    public String getHookIp() {
        return hookIp;
    }

    public void setHookIp(String hookIp) {
        this.hookIp = hookIp;
    }

    public String getSdpIp() {
        return sdpIp;
    }

    public void setSdpIp(String sdpIp) {
        this.sdpIp = sdpIp;
    }

    public String getStreamIp() {
        return streamIp;
    }

    public void setStreamIp(String streamIp) {
        this.streamIp = streamIp;
    }

    public int getHttpPort() {
        return httpPort;
    }

    public void setHttpPort(int httpPort) {
        this.httpPort = httpPort;
    }

    public int getHttpSSlPort() {
        return httpSSlPort;
    }

    public void setHttpSSlPort(int httpSSlPort) {
        this.httpSSlPort = httpSSlPort;
    }

    public int getRtmpPort() {
        return rtmpPort;
    }

    public void setRtmpPort(int rtmpPort) {
        this.rtmpPort = rtmpPort;
    }

    public int getRtmpSSlPort() {
        return rtmpSSlPort;
    }

    public void setRtmpSSlPort(int rtmpSSlPort) {
        this.rtmpSSlPort = rtmpSSlPort;
    }

    public int getRtpProxyPort() {
        return rtpProxyPort;
    }

    public void setRtpProxyPort(int rtpProxyPort) {
        this.rtpProxyPort = rtpProxyPort;
    }

    public int getRtspPort() {
        return rtspPort;
    }

    public void setRtspPort(int rtspPort) {
        this.rtspPort = rtspPort;
    }

    public int getRtspSSLPort() {
        return rtspSSLPort;
    }

    public void setRtspSSLPort(int rtspSSLPort) {
        this.rtspSSLPort = rtspSSLPort;
    }

    public boolean isAutoConfig() {
        return autoConfig;
    }

    public void setAutoConfig(boolean autoConfig) {
        this.autoConfig = autoConfig;
    }

    public String getSecret() {
        return secret;
    }

    public void setSecret(String secret) {
        this.secret = secret;
    }

    public int getStreamNoneReaderDelayMS() {
        return streamNoneReaderDelayMS;
    }

    public void setStreamNoneReaderDelayMS(int streamNoneReaderDelayMS) {
        this.streamNoneReaderDelayMS = streamNoneReaderDelayMS;
    }

    public boolean isRtpEnable() {
        return rtpEnable;
    }

    public void setRtpEnable(boolean rtpEnable) {
        this.rtpEnable = rtpEnable;
    }

    public String getRtpPortRange() {
        return rtpPortRange;
    }

    public void setRtpPortRange(String rtpPortRange) {
        this.rtpPortRange = rtpPortRange;
    }

    public int getRecordAssistPort() {
        return recordAssistPort;
    }

    public void setRecordAssistPort(int recordAssistPort) {
        this.recordAssistPort = recordAssistPort;
    }

    public boolean isDefaultServer() {
        return defaultServer;
    }

    public void setDefaultServer(boolean defaultServer) {
        this.defaultServer = defaultServer;
    }

    public String getCreateTime() {
        return createTime;
    }

    public void setCreateTime(String createTime) {
        this.createTime = createTime;
    }

    public String getUpdateTime() {
        return updateTime;
    }

    public void setUpdateTime(String updateTime) {
        this.updateTime = updateTime;
    }

    public HashMap<String, SsrcConfig> getMediaServerSsrcMap() {
        return mediaServerSsrcMap;
    }

    public void setMediaServerSsrcMap(HashMap<String, SsrcConfig> mediaServerSsrcMap) {
        this.mediaServerSsrcMap = mediaServerSsrcMap;
    }

    public SsrcConfig getSsrcConfig() {
        return ssrcConfig;
    }

    public void setSsrcConfig(SsrcConfig ssrcConfig) {
        this.ssrcConfig = ssrcConfig;
    }

    public int getCurrentPort() {
        return currentPort;
    }

    public void setCurrentPort(int currentPort) {
        this.currentPort = currentPort;
    }

    public boolean isStatus() {
        return status;
    }

    public void setStatus(boolean status) {
        this.status = status;
    }

    public String getLastKeepaliveTime() {
        return lastKeepaliveTime;
    }

    public void setLastKeepaliveTime(String lastKeepaliveTime) {
        this.lastKeepaliveTime = lastKeepaliveTime;
    }

    public String getSendRtpPortRange() {
        return sendRtpPortRange;
    }

    public void setSendRtpPortRange(String sendRtpPortRange) {
        this.sendRtpPortRange = sendRtpPortRange;
    }

    public int getHookAliveInterval() {
        return hookAliveInterval;
    }

    public void setHookAliveInterval(int hookAliveInterval) {
        this.hookAliveInterval = hookAliveInterval;
    }
}
